﻿using System;
using System.Collections.Generic;
using System.Text;
using System.Windows;
using System.IO;
using System.Windows.Controls;
using System.Windows.Input;

namespace 任务管理器
{
    /// <summary>
    /// 任务编辑窗口.xaml 的交互逻辑
    /// </summary>
    public partial class 任务编辑窗口 : Window
    {
        #region 构造方法
        List<任务套> 任务数据;
        string 配置文件保存路径 = 数据集.配置文件保存路径;
        string 当前编辑任务名称 = "";
        public 任务编辑窗口(List<任务套> 任务)
        {
            任务数据 = 任务;
            InitializeComponent();
            初始化窗口内容();
            Console.WriteLine(配置文件保存路径);
        }
        public 任务编辑窗口(List<任务套> 任务, string 任务名)
        {
            任务数据 = 任务;
            InitializeComponent();
            初始化窗口内容();
            读取文件(任务名);

        }
        public 任务编辑窗口(string 任务名)
        {
            配置项 配置 = new 配置项();
            string 配置文件 = $"{ 配置文件保存路径 }{任务名}.cfg";
            if (配置.读取(配置文件, "基础信息", "任务状态", "错误") == 任务.任务执行状态.已完成.ToString())
            {
                return;
            }

            配置.写入(配置文件, "基础信息", "任务状态", 任务.任务执行状态.已完成.ToString());
            配置.写入(配置文件, "基础信息", "任务进度", "100");
            重读任务();
            重读信息();
            return;
        }
        #endregion
        #region 委托主窗
        public delegate void 重新读取所有任务();
        public delegate void 重新读取界面信息();
        public 重新读取所有任务 重读任务;
        public 重新读取所有任务 重读信息;
        #endregion
        #region 主任务增删改查
        public void 储存文件()
        {
            同步更新项数();
            if (任务名.Text.Length < 2) { MessageBox.Show("请输入正确的任务名称", "没有任务名"); return; }
            if (任务类别.Text.Length < 2) { MessageBox.Show("请输入正确的任务类别", "没有任务类别"); return; }
            if (任务状态.Text.Length < 2) { MessageBox.Show("请选择正确的任务状态", "没有任务状态"); return; }
            配置项 配置 = new 配置项();
            文件 文件 = new 文件();
            正则 正则 = new 正则();
            //检查文件夹情况
            if (Directory.Exists(配置文件保存路径) == false) { Directory.CreateDirectory(配置文件保存路径); }
            配置文件保存路径 += "\\";
            string 配置文件 = $"{ 配置文件保存路径 }{ 任务名.Text}.cfg";
            string 描述文件 = $"{ 配置文件保存路径 }{ 任务名.Text}.tdf";
            //储存配置文件
            配置.写入(配置文件, "基础信息", "类别", 任务类别.Text);
            配置.写入(配置文件, "基础信息", "名称", 任务名.Text);
            配置.写入(配置文件, "基础信息", "任务状态", 任务状态.Text);
            配置.写入(配置文件, "基础信息", "任务进度", 任务进度.Value.ToString());
            配置.写入(配置文件, "基础信息", "当前项", 最低项数.Value.ToString());
            配置.写入(配置文件, "基础信息", "最高项", 最高项数.Value.ToString());
            文件.写入文件(描述文件, 任务描述.Text);
            配置.写入(配置文件, "高级设定", "时间模式", 任务时间模式.Text.ToString());
            配置.写入(配置文件, "高级设定", "启动时间", 启动时间.SelectedDateTime.Value.ToString());
            配置.写入(配置文件, "高级设定", "时间设定", 任务期限.SelectedDateTime.Value.ToString());
            if (任务期限.Text.Length < 5) { 配置.写入(配置文件, "高级设定", "时间设定", "2000-1-1"); }
            配置.写入(配置文件, "高级设定", "启用命令行", 启用命令行.IsChecked.ToString());
            配置.写入(配置文件, "高级设定", "命令行内容", 命令行内容.Text);
            配置.写入(配置文件, "高级设定", "启用文本行", 启用文本.IsChecked.ToString());
            配置.写入(配置文件, "高级设定", "文本行内容", 文本命令.Text);
            //子任务逻辑

            if (子任务列启用按钮.IsChecked.Value)
            {
                配置.写入(配置文件, "任务子项", "是否启用", "true");
                储存子任务(配置文件);
            }
            else
            {
                配置.写入(配置文件, "任务子项", "是否启用", "false");
                储存子任务(配置文件);
            }
            //任务替换逻辑
            if (当前编辑任务名称 != 任务名.Text && 当前编辑任务名称.Length > 0)
            {
                配置文件 = $"{ 配置文件保存路径 }{ 当前编辑任务名称}.cfg";
                描述文件 = $"{ 配置文件保存路径 }{当前编辑任务名称}.tdf";
                string 子任务配置文件保存路径 = $"{配置文件保存路径}{ 当前编辑任务名称}";
                File.Delete(配置文件);
                File.Delete(描述文件);
                if (Directory.Exists(子任务配置文件保存路径)) { Directory.Delete(子任务配置文件保存路径); }

            }

            //时间设定逻辑
            if (任务时间模式.Text != 任务.时间模式.不使用.ToString())
            {
                if (启动时间.SelectedDateTime > 任务期限.SelectedDateTime)
                {
                    MessageBox.Show("任务的其他信息已保存，但是无法保存时间，请先确定启动时间不大于任务期限的时间", "保存");
                    配置.写入(配置文件, "高级设定", "时间模式", 任务.时间模式.不使用.ToString());
                }

                if (DateTime.Now > 任务期限.SelectedDateTime)
                {
                    MessageBox.Show("任务的其他信息已保存，但是无法保存时间，请先确定任务是否已经过期", "保存");
                    配置.写入(配置文件, "高级设定", "时间模式", 任务.时间模式.不使用.ToString());
                }

            }



        }
        public void 读取文件(string 任务名称)
        {
            配置项 配置 = new 配置项();
            文件 文件 = new 文件();
            正则 正则 = new 正则();
            当前编辑任务名称 = 任务名称;
            配置文件保存路径 += "\\";
            string 配置文件 = $"{ 配置文件保存路径 }{当前编辑任务名称}.cfg";
            string 描述文件 = $"{ 配置文件保存路径 }{当前编辑任务名称}.tdf";
            string 子任务配置文件保存路径 = $"{配置文件保存路径}{ 当前编辑任务名称}";
            //读取配置文件
            任务类别.Text = 配置.读取(配置文件, "基础信息", "类别", "读取失败");
            任务名.Text = 配置.读取(配置文件, "基础信息", "名称", "读取失败");
            任务状态.Text = 配置.读取(配置文件, "基础信息", "任务状态", "读取失败");
            任务进度.Value = double.Parse(配置.读取(配置文件, "基础信息", "任务进度", "0"));
            最低项数.Value = int.Parse(配置.读取(配置文件, "基础信息", "当前项", "0"));
            最高项数.Value = int.Parse(配置.读取(配置文件, "基础信息", "最高项", "0"));
            任务描述.Text = 文件.读入文件_快速(描述文件, Encoding.GetEncoding("GB2312"));
            任务时间模式.Text = 配置.读取(配置文件, "高级设定", "时间模式", "读取失败");
            任务期限.SelectedDateTime = DateTime.Parse(配置.读取(配置文件, "高级设定", "时间设定", "读取失败"));
            启动时间.SelectedDateTime = DateTime.Parse(配置.读取(配置文件, "高级设定", "启动时间", DateTime.Now.ToString()));
            启用命令行.IsChecked = bool.Parse(配置.读取(配置文件, "高级设定", "启用命令行", "false"));
            命令行内容.Text = 配置.读取(配置文件, "高级设定", "命令行内容", "读取失败");
            启用文本.IsChecked =  bool.Parse(配置.读取(配置文件, "高级设定", "启用文本行", "false"));
            文本命令.Text = 配置.读取(配置文件, "高级设定", "文本行内容", "");
            //子任务逻辑
            读取子任务(配置文件);
            //倒计时逻辑
            if (任务期限.SelectedDateTime > DateTime.Now)
            {
                var 增加值 = 任务期限.SelectedDateTime.Value.Subtract(DateTime.Now);
                string 增加时 = 增加值.Hours.ToString();
                string 增加分 = 增加值.Minutes.ToString();
                string 增加秒 = 增加值.Seconds.ToString();
                时间增加值.SelectedTime = DateTime.Parse($"{增加时}:{增加分}:{增加秒}");

            }

        }
        public void 删除文件()
        {

            string 配置文件 = $"{ 配置文件保存路径 }{当前编辑任务名称}.cfg";
            if (File.Exists(配置文件) == false)
            {
                var 是否删除框 = MessageBox.Show("要删除当前正在编辑的所有内容吗", "删除", MessageBoxButton.OKCancel, MessageBoxImage.Warning);
                if (是否删除框 == MessageBoxResult.OK)
                {
                    任务类别.Text = "";
                    任务名.Text = "";
                    任务状态.Text = "";
                    任务进度.Value = 0;
                    任务描述.Text = "";
                    任务时间模式.Text = "";
                    任务期限.Text = "";
                    启用命令行.IsChecked = false;
                    子任务列启用按钮.IsChecked = false;
                    命令行内容.Text = "";
                    子任务列.Items.Clear();
                    return;
                }
            }
            if (File.Exists(配置文件))
            {
                var 是否删除框 = MessageBox.Show("要删除当前的任务吗？\r\n删除后当前任务下的子任务将被一并删除，该操作无法撤销！", "删除", MessageBoxButton.OKCancel, MessageBoxImage.Warning);
                if (是否删除框 == MessageBoxResult.OK)
                {
                    string 描述文件 = $"{ 配置文件保存路径 }{当前编辑任务名称}.tdf";
                    string 子任务配置文件保存路径 = $"{配置文件保存路径}{ 当前编辑任务名称}";
                    File.Delete(配置文件);
                    File.Delete(描述文件);
                    if (Directory.Exists(子任务配置文件保存路径)) { Directory.Delete(子任务配置文件保存路径); }
                    MessageBox.Show("已成功删除", "删除", MessageBoxButton.OK, MessageBoxImage.Information);
                    重读任务();
                    重读信息();
                    this.Close();
                }
            }


        }
        #endregion
        #region 子任务增删改查
        public void 读取子任务(string 配置文件)
        {
            子任务列.Items.Clear();
            配置项 配置 = new 配置项();
            子任务列启用按钮.IsChecked = bool.Parse(配置.读取(配置文件, "任务子项", "是否启用", "false"));
            string 子任务原数据 = 配置.读取(配置文件, "子任务", "子任务组", "");
            if (子任务原数据.Length < 2) { return; }
            string[] 子任务集 = 子任务原数据.Split('|');
            foreach (string 子任务名 in 子任务集)
            {
                CheckBox 勾选控件 = new CheckBox();
                勾选控件.Content = 子任务名;
                勾选控件.IsChecked = bool.Parse(配置.读取(配置文件, "子任务", 子任务名, "false"));
                子任务列.Items.Add(勾选控件);
            }
            界面不可用状态设定();
        }
        public void 储存子任务(string 配置文件)
        {
            配置项 配置 = new 配置项();
            //储存子任务集
            var 子任务集原数据 = 子任务列.Items;
            string 子任务集新数据 = "";
            foreach (object 子任务项 in 子任务集原数据)
            {
                CheckBox 任务 = (CheckBox)子任务项;
                if (子任务集新数据.Length == 0) { 子任务集新数据 += 任务.Content.ToString(); }
                else { 子任务集新数据 += $"|{任务.Content.ToString()}"; }

                配置.写入(配置文件, "子任务", 任务.Content.ToString(), 任务.IsChecked.ToString());

            }
            配置.写入(配置文件, "子任务", "子任务组", 子任务集新数据);
        }
        public void 新建子任务(string 任务名称)
        {
            CheckBox 子任务 = new CheckBox();
            子任务.Content = 任务名称;
            子任务列.Items.Add(子任务);

        }
        public void 删除子任务(string 配置文件)
        {
            子任务列.Items.Remove(子任务列.SelectedItem);
        }
        #endregion
        #region UI控制
        public void 同步更新进度条()
        {
            if (this.IsInitialized == false) { return; }
            if (最低项数.Value == 0) { 任务进度.Value = 0; return; }
            if (最高项数.Value == 0) { 任务进度.Value = 0; return; }
            任务进度.Value = 最低项数.Value / 最高项数.Value * 100;
        }
        public void 同步更新项数()
        {
            //更新项数
            if (子任务列启用按钮.IsChecked == true)
            {
                最高项数.Value = 子任务列.Items.Count;
                最高项数.Maximum = 子任务列.Items.Count;
                最低项数.Value = 0;
                //取最低项数 
                var 子任务集原数据 = 子任务列.Items;
                string 子任务集新数据 = "";
                foreach (object 子任务项 in 子任务集原数据)
                {
                    CheckBox 任务 = (CheckBox)子任务项;
                    if (任务.IsChecked == true) { 最低项数.Value++; }

                }
            }
            else
            { 最高项数.Maximum = 990000000; }
        }
        public void 界面不可用状态设定()
        {
            //子任务界面
            if (子任务列启用按钮.IsChecked == true)
            {
                最高项数.Value = 子任务列.Items.Count;
                最低项数.Value = 0;
                foreach (object i in 子任务列.Items)
                {
                    CheckBox 当前遍历框 = (CheckBox)i;
                    if (当前遍历框.IsChecked.Value) { 最低项数.Value += 1; }
                }
                最低项数.IsEnabled = false;
                最高项数.IsEnabled = false;
            }
            else
            {
                最低项数.IsEnabled = true;
                最高项数.IsEnabled = true;
            }

            if (子任务列启用按钮.IsChecked == false)
            {
                最低项数.IsEnabled = true;
                最高项数.IsEnabled = true;
            }

            //时钟界面
            if (任务时间模式.Text == 任务.时间模式.不使用.ToString()) { 启动时间.IsEnabled = false; 任务期限.IsEnabled = false; 时间增加值.IsEnabled = false; }
            else { 启动时间.IsEnabled = true; 任务期限.IsEnabled = true; 时间增加值.IsEnabled = true; }
            if (任务时间模式.Text == 任务.时间模式.正计时间模式.ToString() || 任务时间模式.Text == 任务.时间模式.倒计时间模式.ToString())
            {
                最低项数.IsEnabled = false;
                最高项数.IsEnabled = false;
            }

        }
        public void 初始化窗口内容()
        {
            // 加载类别
            for (int i = 0; i < 任务数据.Count; i++)
            {
                string 当前任务类型 = 任务数据[i].任务信息.任务类别;
                if (任务类别.Items.Contains(当前任务类型) == false) { 任务类别.Items.Add(当前任务类型); }
            }

            //加载状态
            foreach (var 状态 in typeof(任务.任务执行状态).GetFields())
            {
                if (状态.Name.Contains("alue")) { continue; }
                任务状态.Items.Add(状态.Name);
            }

            //任务时间模式
            foreach (var 时间模式 in typeof(任务.时间模式).GetFields())
            {
                if (时间模式.Name.Contains("alue")) { continue; }
                任务时间模式.Items.Add(时间模式.Name);
            }

            //子任务列设定
            子任务列.Items.Clear();

            //时间控制设定
            任务时间模式.Text = Enum.GetName(typeof(任务.时间模式), 任务.时间模式.不使用);
            时间增加值.SelectedTime = DateTime.Parse("0:00:00");
            任务期限.SelectedDateTime = DateTime.Now;
            启动时间.SelectedDateTime = DateTime.Now;

        }
        private void 新建任务菜单_Click(object sender, RoutedEventArgs e)
        {

            新建按钮 新建 = new 新建按钮();
            新建.新建任务 = 新建子任务;
            新建.Show();
        }
        private void 保存_Click(object sender, RoutedEventArgs e)
        {
            储存文件();
            MessageBox.Show("保存成功", "储存");
            重读任务();
            重读信息();
            this.Close();
        }
        private void 删除_Click(object sender, RoutedEventArgs e)
        {
            删除文件();
        }

        private void 项数修改(object sender, HandyControl.Data.FunctionEventArgs<double> e)
        {

            同步更新进度条();

        }

        private void 任务进度_ValueChanged(object sender, HandyControl.Data.FunctionEventArgs<double> e)
        {


        }

        private void 子任务列启用按钮_Checked(object sender, RoutedEventArgs e)
        {
            界面不可用状态设定();
        }

        private void 子任务列启用按钮_Click(object sender, RoutedEventArgs e)
        {
            界面不可用状态设定();
        }

        private void 子任务列_MouseDown(object sender, MouseButtonEventArgs e)
        {
            界面不可用状态设定();
        }

        private void 子任务列_MouseDown(object sender, RoutedEventArgs e)
        {
            界面不可用状态设定();
        }

        private void 子任务列_MouseDown(object sender, MouseEventArgs e)
        {
            界面不可用状态设定();

        }


        private void 时间增加值_SelectedTimeChanged(object sender, HandyControl.Data.FunctionEventArgs<DateTime?> e)
        {
            DateTime 增加值 = 时间增加值.SelectedTime.Value;
            string 增加时 = 增加值.Hour.ToString();
            string 增加分 = 增加值.Minute.ToString();
            string 增加秒 = 增加值.Second.ToString();
            任务期限.SelectedDateTime = DateTime.Now.Add(TimeSpan.Parse($"{增加时}:{增加分}:{增加秒}"));

        }

        private void Window_Closing(object sender, System.ComponentModel.CancelEventArgs e)
        {

        }


        private void 子任务列_ContextMenuOpening(object sender, ContextMenuEventArgs e)
        {
            if (子任务列.SelectedIndex != -1)
            {
                删除按钮.Visibility = Visibility.Visible;
                编辑按钮.Visibility = Visibility.Visible;
            }
            else
            {
                删除按钮.Visibility = Visibility.Collapsed;
                编辑按钮.Visibility = Visibility.Collapsed;
            }
        }


        private void 删除按钮_Click(object sender, RoutedEventArgs e)
        {
            string 配置文件 = $"{ 配置文件保存路径 }{任务名.Text}.cfg";
            删除子任务(配置文件);
        }

        private void TabControl_SelectionChanged(object sender, SelectionChangedEventArgs e)
        {
            同步更新项数();
            界面不可用状态设定();
        }


        private void 任务时间模式_SelectionChanged_1(object sender, SelectionChangedEventArgs e)
        {
            if (任务时间模式.Text != "")
            {
                任务时间模式.Text = 任务时间模式.SelectedItem.ToString();

            }
            Console.WriteLine(28781974230);
            Console.WriteLine(任务时间模式.Text);
        }

        private void 编辑按钮_Click(object sender, RoutedEventArgs e)
        {
            CheckBox 子任务 = (CheckBox)子任务列.SelectedItem;
            新建按钮 修改 = new 新建按钮(子任务);
            修改.Show();
        }

        #endregion

    }
}
